home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1996-09-22  |  16.3 KB  |  590 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MoviesFormat.p
  3.  
  4.      Contains:    QuickTime Interfaces.
  5.  
  6.      Version:    Technology:    QuickTime 2.5
  7.                  Release:    Universal Interfaces 2.1.4
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT MoviesFormat;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __MOVIESFORMAT__}
  28. {$SETC __MOVIESFORMAT__ := 1}
  29.  
  30. {$I+}
  31. {$SETC MoviesFormatIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __WINDOWS__}
  38. {$I Windows.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  41. {$I ImageCompression.p}
  42. {$ENDC}
  43. {$IFC UNDEFINED __MOVIES__}
  44. {$I Movies.p}
  45. {$ENDC}
  46.  
  47. {$PUSH}
  48. {$ALIGN MAC68K}
  49. {$LibExport+}
  50.  
  51.  
  52. CONST
  53.     kMovieVersion                = 0;                            {  version number of the format here described  }
  54.  
  55. {
  56. ***************************************
  57. *
  58. *   General Types -
  59. *        These types are used in more than one of the
  60. *        directory types.
  61. *
  62. ***************************************
  63. }
  64. {  MoviesUserData is the type used for user data in movie and track directories  }
  65.  
  66. TYPE
  67.     MoviesUserDataPtr = ^MoviesUserData;
  68.     MoviesUserData = RECORD
  69.         size:                    LONGINT;                                {  size of this user data  }
  70.         udType:                    LONGINT;                                {  type of user data  }
  71.         data:                    SInt8;                                    {  the user data  }
  72.     END;
  73.  
  74.     UserDataAtomPtr = ^UserDataAtom;
  75.     UserDataAtom = RECORD
  76.         size:                    LONGINT;
  77.         atomType:                LONGINT;
  78.         userData:                ARRAY [0..0] OF MoviesUserData;
  79.     END;
  80.  
  81. {
  82.  MoviesDataDescription tells us where the data for the movie or track lives.
  83.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  84.    be in the resource fork of the same file as the directory resource, be in another file in the
  85.    data fork or resource fork, or require a specific bottleneck to fetch the data. 
  86. }
  87. {
  88. ***************************************
  89. *
  90. *   MediaDirectory information -
  91. *        The MediaDirectory is tightly coupled to the data.
  92. *
  93. ***************************************
  94. }
  95.     SampleDescriptionAtomPtr = ^SampleDescriptionAtom;
  96.     SampleDescriptionAtom = RECORD
  97.         size:                    LONGINT;
  98.         atomType:                LONGINT;                                {  = 'stsd'  }
  99.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  100.         numEntries:                LONGINT;
  101.         sampleDescTable:        ARRAY [0..0] OF SampleDescription;
  102.     END;
  103.  
  104. {  TimeToSampleNum maps physical sample time to physical sample number.  }
  105.     TimeToSampleNumPtr = ^TimeToSampleNum;
  106.     TimeToSampleNum = RECORD
  107.         sampleCount:            LONGINT;
  108.         sampleDuration:            TimeValue;
  109.     END;
  110.  
  111.     TimeToSampleNumAtomPtr = ^TimeToSampleNumAtom;
  112.     TimeToSampleNumAtom = RECORD
  113.         size:                    LONGINT;
  114.         atomType:                LONGINT;                                {  = 'stts'  }
  115.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  116.         numEntries:                LONGINT;
  117.         timeToSampleNumTable:    ARRAY [0..0] OF TimeToSampleNum;
  118.     END;
  119.  
  120. {  SyncSamples is a list of the physical samples which are self contained.  }
  121.     SyncSampleAtomPtr = ^SyncSampleAtom;
  122.     SyncSampleAtom = RECORD
  123.         size:                    LONGINT;
  124.         atomType:                LONGINT;                                {  = 'stss'  }
  125.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  126.         numEntries:                LONGINT;
  127.         syncSampleTable:        ARRAY [0..0] OF LONGINT;
  128.     END;
  129.  
  130. {  SampleToChunk maps physical sample number to chunk number.  }
  131. {  same as SampleToChunk, but redundant first sample is removed  }
  132.     SampleToChunkPtr = ^SampleToChunk;
  133.     SampleToChunk = RECORD
  134.         firstChunk:                LONGINT;
  135.         samplesPerChunk:        LONGINT;
  136.         sampleDescriptionID:    LONGINT;
  137.     END;
  138.  
  139.     SampleToChunkAtomPtr = ^SampleToChunkAtom;
  140.     SampleToChunkAtom = RECORD
  141.         size:                    LONGINT;
  142.         atomType:                LONGINT;                                {  = 'stsc'  }
  143.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  144.         numEntries:                LONGINT;
  145.         sampleToChunkTable:        ARRAY [0..0] OF SampleToChunk;
  146.     END;
  147.  
  148.     ChunkOffsetAtomPtr = ^ChunkOffsetAtom;
  149.     ChunkOffsetAtom = RECORD
  150.         size:                    LONGINT;
  151.         atomType:                LONGINT;                                {  = 'stco'  }
  152.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  153.         numEntries:                LONGINT;
  154.         chunkOffsetTable:        ARRAY [0..0] OF LONGINT;
  155.     END;
  156.  
  157.     SampleSizeAtomPtr = ^SampleSizeAtom;
  158.     SampleSizeAtom = RECORD
  159.         size:                    LONGINT;
  160.         atomType:                LONGINT;                                {  = 'stsz'  }
  161.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  162.         sampleSize:                LONGINT;
  163.         numEntries:                LONGINT;
  164.         sampleSizeTable:        ARRAY [0..0] OF LONGINT;
  165.     END;
  166.  
  167.     ShadowSyncPtr = ^ShadowSync;
  168.     ShadowSync = RECORD
  169.         fdSampleNum:            LONGINT;
  170.         syncSampleNum:            LONGINT;
  171.     END;
  172.  
  173.     ShadowSyncAtomPtr = ^ShadowSyncAtom;
  174.     ShadowSyncAtom = RECORD
  175.         size:                    LONGINT;
  176.         atomType:                LONGINT;                                {  = 'stsz'  }
  177.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  178.         numEntries:                LONGINT;
  179.         shadowSyncTable:        ARRAY [0..0] OF ShadowSync;
  180.     END;
  181.  
  182.     SampleTableAtomPtr = ^SampleTableAtom;
  183.     SampleTableAtom = RECORD
  184.         size:                    LONGINT;
  185.         atomType:                LONGINT;                                {  = 'stbl'  }
  186.         sampleDescription:        SampleDescriptionAtom;
  187.         timeToSampleNum:        TimeToSampleNumAtom;
  188.         sampleToChunk:            SampleToChunkAtom;
  189.         syncSample:                SyncSampleAtom;
  190.         sampleSize:                SampleSizeAtom;
  191.         chunkOffset:            ChunkOffsetAtom;
  192.         shadowSync:                ShadowSyncAtom;
  193.     END;
  194.  
  195.     PublicHandlerInfoPtr = ^PublicHandlerInfo;
  196.     PublicHandlerInfo = RECORD
  197.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  198.         componentType:            LONGINT;
  199.         componentSubType:        LONGINT;
  200.         componentManufacturer:    LONGINT;
  201.         componentFlags:            LONGINT;
  202.         componentFlagsMask:        LONGINT;
  203.         componentName:            SInt8;
  204.     END;
  205.  
  206.     HandlerAtomPtr = ^HandlerAtom;
  207.     HandlerAtom = RECORD
  208.         size:                    LONGINT;
  209.         atomType:                LONGINT;                                {  = 'hdlr'  }
  210.         hInfo:                    PublicHandlerInfo;
  211.     END;
  212.  
  213. {  a data reference is a private structure  }
  214.     DataRefAtom                            = LONGINT;
  215.     DataInfoAtomPtr = ^DataInfoAtom;
  216.     DataInfoAtom = RECORD
  217.         size:                    LONGINT;
  218.         atomType:                LONGINT;                                {  = 'dinf'  }
  219.         dataRef:                DataRefAtom;
  220.     END;
  221.  
  222.     RgnAtomPtr = ^RgnAtom;
  223.     RgnAtom = RECORD
  224.         size:                    LONGINT;
  225.         atomType:                LONGINT;
  226.         rgnSize:                INTEGER;
  227.         rgnBBox:                Rect;
  228.         data:                    SInt8;
  229.     END;
  230.  
  231.     MatteCompressedAtomPtr = ^MatteCompressedAtom;
  232.     MatteCompressedAtom = RECORD
  233.         size:                    LONGINT;
  234.         atomType:                LONGINT;
  235.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  236.         matteImageDescription:    ImageDescription;
  237.         matteData:                SInt8;
  238.     END;
  239.  
  240.     MatteAtomPtr = ^MatteAtom;
  241.     MatteAtom = RECORD
  242.         size:                    LONGINT;
  243.         atomType:                LONGINT;
  244.         aCompressedMatte:        MatteCompressedAtom;
  245.     END;
  246.  
  247.     ClippingAtomPtr = ^ClippingAtom;
  248.     ClippingAtom = RECORD
  249.         size:                    LONGINT;
  250.         atomType:                LONGINT;
  251.         aRgnClip:                RgnAtom;
  252.     END;
  253.  
  254. {
  255. **********************
  256. * Media Info Example Structures
  257. **********************
  258. }
  259.     VideoMediaInfoHeaderPtr = ^VideoMediaInfoHeader;
  260.     VideoMediaInfoHeader = RECORD
  261.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  262.         graphicsMode:            INTEGER;                                {  for QD - transfer mode  }
  263.         opColorRed:                INTEGER;                                {  opcolor for transfer mode  }
  264.         opColorGreen:            INTEGER;
  265.         opColorBlue:            INTEGER;
  266.     END;
  267.  
  268.     VideoMediaInfoHeaderAtomPtr = ^VideoMediaInfoHeaderAtom;
  269.     VideoMediaInfoHeaderAtom = RECORD
  270.         size:                    LONGINT;                                {  size of Media info  }
  271.         atomType:                LONGINT;                                {  = 'vmhd'  }
  272.         vmiHeader:                VideoMediaInfoHeader;
  273.     END;
  274.  
  275.     VideoMediaInfoPtr = ^VideoMediaInfo;
  276.     VideoMediaInfo = RECORD
  277.         size:                    LONGINT;                                {  size of Media info  }
  278.         atomType:                LONGINT;                                {  = 'minf'  }
  279.         header:                    VideoMediaInfoHeaderAtom;
  280.         dataHandler:            HandlerAtom;
  281.         dataInfo:                DataInfoAtom;
  282.         sampleTable:            SampleTableAtom;
  283.     END;
  284.  
  285.     SoundMediaInfoHeaderPtr = ^SoundMediaInfoHeader;
  286.     SoundMediaInfoHeader = RECORD
  287.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  288.         balance:                INTEGER;
  289.         rsrvd:                    INTEGER;
  290.     END;
  291.  
  292.     SoundMediaInfoHeaderAtomPtr = ^SoundMediaInfoHeaderAtom;
  293.     SoundMediaInfoHeaderAtom = RECORD
  294.         size:                    LONGINT;                                {  size of Media info  }
  295.         atomType:                LONGINT;                                {  = 'vmhd'  }
  296.         smiHeader:                SoundMediaInfoHeader;
  297.     END;
  298.  
  299.     SoundMediaInfoPtr = ^SoundMediaInfo;
  300.     SoundMediaInfo = RECORD
  301.         size:                    LONGINT;                                {  size of Media info  }
  302.         atomType:                LONGINT;                                {  = 'minf'  }
  303.         header:                    SoundMediaInfoHeaderAtom;
  304.         dataHandler:            HandlerAtom;
  305.         dataReference:            DataRefAtom;
  306.         sampleTable:            SampleTableAtom;
  307.     END;
  308.  
  309. {  whatever data the media handler needs goes after the atomType  }
  310.     MediaInfoPtr = ^MediaInfo;
  311.     MediaInfo = RECORD
  312.         size:                    LONGINT;
  313.         atomType:                LONGINT;
  314.     END;
  315.  
  316. {
  317. **********************
  318. * Media Directory Structures
  319. **********************
  320. }
  321.     MediaHeaderPtr = ^MediaHeader;
  322.     MediaHeader = RECORD
  323.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  324.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  325.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  326.         timeScale:                TimeValue;                                {  start time for Media (Media time)  }
  327.         duration:                TimeValue;                                {  length of Media (Media time)  }
  328.         language:                INTEGER;
  329.         quality:                INTEGER;
  330.     END;
  331.  
  332.     MediaHeaderAtomPtr = ^MediaHeaderAtom;
  333.     MediaHeaderAtom = RECORD
  334.         size:                    LONGINT;
  335.         atomType:                LONGINT;
  336.         header:                    MediaHeader;
  337.     END;
  338.  
  339.     MediaDirectoryPtr = ^MediaDirectory;
  340.     MediaDirectory = RECORD
  341.         size:                    LONGINT;
  342.         atomType:                LONGINT;                                {  = 'mdia'  }
  343.         mediaHeader:            MediaHeaderAtom;                        {  standard Media information  }
  344.         mediaHandler:            HandlerAtom;
  345.         mediaInfo:                MediaInfo;
  346.     END;
  347.  
  348. {
  349. **********************
  350. * Track Structures
  351. **********************
  352. }
  353.  
  354. CONST
  355.     TrackEnable                    = $01;
  356.     TrackInMovie                = $02;
  357.     TrackInPreview                = $04;
  358.     TrackInPoster                = $08;
  359.  
  360.  
  361. TYPE
  362.     TrackHeaderPtr = ^TrackHeader;
  363.     TrackHeader = RECORD
  364.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  365.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  366.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  367.         trackID:                LONGINT;
  368.         reserved1:                LONGINT;
  369.         duration:                TimeValue;                                {  length of track (track time)  }
  370.         reserved2:                LONGINT;
  371.         reserved3:                LONGINT;
  372.         layer:                    INTEGER;
  373.         alternateGroup:            INTEGER;
  374.         volume:                    INTEGER;
  375.         reserved4:                INTEGER;
  376.         matrix:                    MatrixRecord;
  377.         trackWidth:                Fixed;
  378.         trackHeight:            Fixed;
  379.     END;
  380.  
  381.     TrackHeaderAtomPtr = ^TrackHeaderAtom;
  382.     TrackHeaderAtom = RECORD
  383.         size:                    LONGINT;                                {  size of track header  }
  384.         atomType:                LONGINT;                                {  = 'tkhd'  }
  385.         header:                    TrackHeader;
  386.     END;
  387.  
  388.     EditListTypePtr = ^EditListType;
  389.     EditListType = RECORD
  390.         trackDuration:            TimeValue;
  391.         mediaTime:                TimeValue;
  392.         mediaRate:                Fixed;
  393.     END;
  394.  
  395.     EditListAtomPtr = ^EditListAtom;
  396.     EditListAtom = RECORD
  397.         size:                    LONGINT;
  398.         atomType:                LONGINT;                                {  = elst  }
  399.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  400.         numEntries:                LONGINT;
  401.         editListTable:            ARRAY [0..0] OF EditListType;
  402.     END;
  403.  
  404.     EditsAtomPtr = ^EditsAtom;
  405.     EditsAtom = RECORD
  406.         size:                    LONGINT;
  407.         atomType:                LONGINT;                                {  = edts  }
  408.         editList:                EditListAtom;
  409.     END;
  410.  
  411.     TrackLoadSettingsPtr = ^TrackLoadSettings;
  412.     TrackLoadSettings = RECORD
  413.         preloadStartTime:        TimeValue;
  414.         preloadDuration:        TimeValue;
  415.         preloadFlags:            LONGINT;
  416.         defaultHints:            LONGINT;
  417.     END;
  418.  
  419.     TrackLoadSettingsAtomPtr = ^TrackLoadSettingsAtom;
  420.     TrackLoadSettingsAtom = RECORD
  421.         size:                    LONGINT;
  422.         atomType:                LONGINT;                                {  = load  }
  423.         settings:                TrackLoadSettings;
  424.     END;
  425.  
  426.     TrackDirectoryPtr = ^TrackDirectory;
  427.     TrackDirectory = RECORD
  428.         size:                    LONGINT;
  429.         atomType:                LONGINT;                                {  = 'trak'  }
  430.         trackHeader:            TrackHeaderAtom;                        {  standard track information  }
  431.         trackClip:                ClippingAtom;
  432.         edits:                    EditsAtom;
  433.         media:                    MediaDirectory;
  434.         userData:                UserDataAtom;                            {  space for extending with new data types  }
  435.     END;
  436.  
  437. {
  438. ***************************************
  439. *
  440. *   MovieDirectory -
  441. *        The MovieDirectory is the top level structure which
  442. *        holds the TrackInstance describing where the
  443. *        TrackDirectories are.
  444. *
  445. ***************************************
  446. }
  447.     MovieHeaderPtr = ^MovieHeader;
  448.     MovieHeader = RECORD
  449.         flags:                    LONGINT;                                {  1 byte of version / 3 bytes of flags  }
  450.         creationTime:            LONGINT;                                {  seconds since Jan 1904 when directory was created  }
  451.         modificationTime:        LONGINT;                                {  seconds since Jan 1904 when directory was appended  }
  452.         timeScale:                TimeValue;                                {  Time specifications  }
  453.         duration:                TimeValue;
  454.         preferredRate:            Fixed;                                    {  rate at which to play this movie  }
  455.         preferredVolume:        INTEGER;                                {  volume to play movie at  }
  456.         reserved1:                INTEGER;
  457.         preferredLong1:            LONGINT;
  458.         preferredLong2:            LONGINT;
  459.         matrix:                    MatrixRecord;
  460.         previewTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  461.         previewDuration:        TimeValue;                                {  how long the proxy lasts (track time)  }
  462.         posterTime:                TimeValue;                                {  time in track the proxy begins (track time)  }
  463.         selectionTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  464.         selectionDuration:        TimeValue;                                {  time in track the proxy begins (track time)  }
  465.         currentTime:            TimeValue;                                {  time in track the proxy begins (track time)  }
  466.         nextTrackID:            LONGINT;                                {  next value to use for a TrackID  }
  467.     END;
  468.  
  469.     MovieHeaderAtomPtr = ^MovieHeaderAtom;
  470.     MovieHeaderAtom = RECORD
  471.         size:                    LONGINT;
  472.         atomType:                LONGINT;                                {  = 'mvhd'  }
  473.         header:                    MovieHeader;
  474.     END;
  475.  
  476.     TrackDirectoryEntryPtr = ^TrackDirectoryEntry;
  477.     TrackDirectoryEntry = RECORD
  478.         trackDirectory:            TrackDirectory;                            {  Track directory information  }
  479.     END;
  480.  
  481.     MovieDirectoryPtr = ^MovieDirectory;
  482.     MovieDirectory = RECORD
  483.         size:                    LONGINT;
  484.         atomType:                LONGINT;                                {  = 'moov'  }
  485.         header:                    MovieHeaderAtom;
  486.         movieClip:                ClippingAtom;
  487.                                                                         {  Track Directories  }
  488.         track:                    ARRAY [0..0] OF TrackDirectoryEntry;    {  Track directory information  }
  489.                                                                         {  User data for Movie  }
  490.         userData:                UserDataAtom;                            {  space for user extensions  }
  491.     END;
  492.  
  493. {
  494. ***************************************
  495. ***************************************
  496. }
  497. {  Movie formats and tags  }
  498.  
  499. CONST
  500.                                                                 {  some system defined format IDs  }
  501.     MOVIE_TYPE                    = 'moov';
  502.     TRACK_TYPE                    = 'trak';
  503.     MEDIA_TYPE                    = 'mdia';
  504.     VIDEO_TYPE                    = 'vide';
  505.     SOUND_TYPE                    = 'soun';
  506.  
  507. {  atom id's  }
  508.     MovieAID                    = 'moov';
  509.     MovieHeaderAID                = 'mvhd';
  510.     ClipAID                        = 'clip';
  511.     RgnClipAID                    = 'crgn';
  512.     MatteAID                    = 'matt';
  513.     MatteCompAID                = 'kmat';
  514.     TrackAID                    = 'trak';
  515.     UserDataAID                    = 'udta';
  516.     TrackHeaderAID                = 'tkhd';
  517.     EditsAID                    = 'edts';
  518.     EditListAID                    = 'elst';
  519.     MediaAID                    = 'mdia';
  520.     MediaHeaderAID                = 'mdhd';
  521.     MediaInfoAID                = 'minf';
  522.     VideoMediaInfoHeaderAID        = 'vmhd';
  523.     SoundMediaInfoHeaderAID        = 'smhd';
  524.     GenericMediaInfoHeaderAID    = 'gmhd';
  525.     GenericMediaInfoAID            = 'gmin';
  526.     DataInfoAID                    = 'dinf';
  527.     DataRefAID                    = 'dref';
  528.     SampleTableAID                = 'stbl';
  529.     STSampleDescAID                = 'stsd';
  530.     STTimeToSampAID                = 'stts';
  531.     STSyncSampleAID                = 'stss';
  532.     STSampleToChunkAID            = 'stsc';
  533.     STShadowSyncAID                = 'stsh';
  534.     HandlerAID                    = 'hdlr';
  535.     STSampleSizeAID                = 'stsz';
  536.     STChunkOffsetAID            = 'stco';
  537.     STChunkOffset64AID            = 'co64';
  538.     DataRefContainerAID            = 'drfc';
  539.     TrackReferenceAID            = 'tref';
  540.     ColorTableAID                = 'ctab';
  541.     LoadSettingsAID                = 'load';
  542.     PropertyAtomAID                = 'code';
  543.     InputMapAID                    = 'imap';
  544.     MovieBufferHintsAID            = 'mbfh';
  545.     MovieDataRefAliasAID        = 'mdra';
  546.     SoundLocalizationAID        = 'sloc';
  547.  
  548. {  Text ATOM definitions }
  549.  
  550. TYPE
  551.     TextBoxAtomPtr = ^TextBoxAtom;
  552.     TextBoxAtom = RECORD
  553.         size:                    LONGINT;
  554.         atomType:                LONGINT;                                {  = 'tbox'  }
  555.         textBox:                Rect;                                    {  New text box (overrides defaultTextBox) }
  556.     END;
  557.  
  558.     HiliteAtomPtr = ^HiliteAtom;
  559.     HiliteAtom = RECORD
  560.         size:                    LONGINT;
  561.         atomType:                LONGINT;                                {  = 'hlit'  }
  562.         selStart:                LONGINT;                                {  hilite selection start character }
  563.         selEnd:                    LONGINT;                                {  hilite selection end character }
  564.     END;
  565.  
  566.     KaraokeRecPtr = ^KaraokeRec;
  567.     KaraokeRec = RECORD
  568.         timeVal:                TimeValue;
  569.         beginHilite:            INTEGER;
  570.         endHilite:                INTEGER;
  571.     END;
  572.  
  573.     KaraokeAtomPtr = ^KaraokeAtom;
  574.     KaraokeAtom = RECORD
  575.         numEntries:                LONGINT;
  576.         karaokeEntries:            ARRAY [0..0] OF KaraokeRec;
  577.     END;
  578.  
  579.  
  580. {$ALIGN RESET}
  581. {$POP}
  582.  
  583. {$SETC UsingIncludes := MoviesFormatIncludes}
  584.  
  585. {$ENDC} {__MOVIESFORMAT__}
  586.  
  587. {$IFC NOT UsingIncludes}
  588.  END.
  589. {$ENDC}
  590.